components/ticketsauce/sources/new-event/new-event.mjs (1)

79-88: Simplify the lastCreated update logic.

The current implementation searches through all events to find the most recent created date, but since newEvents contains only events created after lastCreated, the most recent event in newEvents already represents the new maximum.

Apply this diff to simplify:

       // Update last created date if we have new events
       if (newEvents.length > 0) {
-        // Find the most recent created date
-        const mostRecentEvent = events.reduce((latest, current) => 
-          Date.parse(current.Event.created) > Date.parse(latest.Event.created) 
-            ? current 
-            : latest
-        );
+        // Get the most recent event from newEvents (last in sorted array)
+        const mostRecentEvent = newEvents[newEvents.length - 1];
         this._setLastCreated(mostRecentEvent.Event.created);
       }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

components/ticketsauce/actions/get-ticket-checkin-ids/get-ticket-checkin-ids.mjs (2)

38-50: Use integer props + bounds for pagination params; avoid sending strings.

Define perPage/page as integer with min/max, and send numbers to the API.

@@
-    perPage: {
-      type: "string",
+    perPage: {
+      type: "integer",
       label: "Per Page",
       description: "How many results to retrieve (per page). Max 5000.",
       optional: true,
+      default: 100,
+      min: 1,
+      max: 5000,
     },
@@
-    page: {
-      type: "string",
+    page: {
+      type: "integer",
       label: "Page",
       description: "Which page to return. For example, if per_page is 20, and page is 3, the results would show 41-60.",
       optional: true,
-      default: "1",
+      default: 1,
+      min: 1,
     },
@@
-    const params = {
-      per_page: this.perPage,
-      page: this.page,
-    };
+    const params = {
+      per_page: this.perPage,
+      page: this.page,
+    };

Also applies to: 52-56

---

52-61: Optionally add “paginate all” support to meet the pagination guideline.

Add a boolean paginateAll to fetch all pages in one run; otherwise keep current single-page behavior. As per component checklist.

@@
   props: {
@@
+    paginateAll: {
+      type: "boolean",
+      label: "Paginate All",
+      description: "If true, fetches all pages of check-in IDs.",
+      optional: true,
+      default: false,
+    },
@@
   async run() {
-    const params = {
+    const params = {
       per_page: this.perPage,
       page: this.page,
     };
 
-    return this.ticketsauce.getTicketCheckinIds({
-      eventId: this.eventId,
-      params,
-    });
+    if (!this.paginateAll) {
+      return this.ticketsauce.getTicketCheckinIds({ eventId: this.eventId, params });
+    }
+    const all = [];
+    let page = params.page || 1;
+    while (true) {
+      const res = await this.ticketsauce.getTicketCheckinIds({ eventId: this.eventId, params: { ...params, page } });
+      const items = Array.isArray(res) ? res : (res?.data ?? []);
+      all.push(...items);
+      if (!items.length || (params.per_page && items.length < params.per_page)) break;
+      page += 1;
+    }
+    return all;
   },

Please confirm Ticketsauce’s “Ticket Check-in IDs” endpoint supports per_page/page and whether 5000 is the documented max. If different, we’ll adjust min/max and loop stop conditions.

components/ticketsauce/actions/get-events/get-events.mjs (2)

59-69: Set explicit defaults to match the descriptions.

Descriptions say default sort is date/asc, but props have no defaults. Add them for consistency.

   sortBy: {
     type: "string",
     label: "Sort By",
     description: "Which field to sort by. By default ('date'), will sort events by their start date. Other options are 'name' (event name) or 'city' (the city where the event is located).",
     optional: true,
+    default: "date",
     options: [
       "date",
       "name",
       "city",
     ],
   },
@@
   sortDir: {
     type: "string",
     label: "Sort Direction",
     description: "Which direction you'd like to sort - either ascending ('asc' - the default) or descending ('desc').",
     optional: true,
+    default: "asc",
     options: [
       "asc",
       "desc",
     ],
   },

Also applies to: 70-79

---

87-103: Avoid sending undefined query keys.

Clean the params object before calling the app method to prevent undefined from being sent.

   async run() {
-    const params = {
+    const paramsRaw = {
       partner_id: this.partnerId,
       organization_id: this.organizationId,
       start_after: this.startAfter,
       end_before: this.endBefore,
       active_only: this.activeOnly,
       privacy_type: this.privacyType,
       sort_by: this.sortBy,
       sort_dir: this.sortDir,
       include_performers: this.includePerformers,
     };
-
-    return this.ticketsauce.listEvents({
-      params,
-    });
+    const params = Object.fromEntries(Object.entries(paramsRaw).filter(([, v]) => v !== undefined));
+    return this.ticketsauce.listEvents({ params });
   },

components/ticketsauce/actions/get-orders/get-orders.mjs (3)

38-51: Use integer props + bounds for perPage/page.

Ensure numeric types and enforce API limits (max 500 as described).

   perPage: {
-      type: "string",
+      type: "integer",
       label: "Per Page",
       description: "How many results to retrieve (per page). Max 500.",
       optional: true,
-      default: "100",
+      default: 100,
+      min: 1,
+      max: 500,
     },
   page: {
-      type: "string",
+      type: "integer",
       label: "Page",
       description: "Which page to return. For example, if per_page is 20, and page is 3, the results would show 41-60.",
       optional: true,
-      default: "1",
+      default: 1,
+      min: 1,
     },

---

136-156: Strip undefined query params before request.

Prevents sending dead/undefined keys; keeps requests clean.

-    const params = {
+    const paramsRaw = {
       per_page: this.perPage,
       page: this.page,
       q: this.q,
       return_questionnaires: this.returnQuestionnaires,
       return_tickets: this.returnTickets,
       return_line_item_fees: this.returnLineItemFees,
       ordered_after: this.orderedAfter,
       ordered_before: this.orderedBefore,
       modified_after: this.modifiedAfter,
       modified_before: this.modifiedBefore,
       sort_by: this.sortBy,
       sort_dir: this.sortDir,
       total_above: this.totalAbove,
       total_below: this.totalBelow,
     };
+    const params = Object.fromEntries(Object.entries(paramsRaw).filter(([, v]) => v !== undefined));
 
     return this.ticketsauce.listOrders({
       eventId: this.eventId,
       params,
     });

---

38-75: Optional: add paginateAll to fetch all pages in one action.

Meets the “handle pagination” checklist; keeps current behavior default.

@@
   props: {
@@
+    paginateAll: {
+      type: "boolean",
+      label: "Paginate All",
+      description: "If true, fetches all pages of orders.",
+      optional: true,
+      default: false,
+    },
@@
   async run() {
-    const paramsRaw = {
+    const paramsRaw = {
       per_page: this.perPage,
       page: this.page,
@@
-    const params = Object.fromEntries(Object.entries(paramsRaw).filter(([, v]) => v !== undefined));
-
-    return this.ticketsauce.listOrders({
-      eventId: this.eventId,
-      params,
-    });
+    const params = Object.fromEntries(Object.entries(paramsRaw).filter(([, v]) => v !== undefined));
+    if (!this.paginateAll) {
+      return this.ticketsauce.listOrders({ eventId: this.eventId, params });
+    }
+    const all = [];
+    let page = params.page || 1;
+    while (true) {
+      const res = await this.ticketsauce.listOrders({ eventId: this.eventId, params: { ...params, page } });
+      const items = Array.isArray(res) ? res : (res?.data ?? []);
+      all.push(...items);
+      if (!items.length || (params.per_page && items.length < params.per_page)) break;
+      page += 1;
+    }
+    return all;
   },

Confirm Ticketsauce’s “Orders” endpoint page size limit (doc says 500 here). If different, update max.

Also applies to: 100-121, 135-157

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

components/ticketsauce/sources/new-event/new-event.mjs (1)

78-84: Consider clarifying the cursor update logic.

The logic correctly updates lastCreated to the most recent event from the full events array (not just newEvents), which properly advances the cursor. However, the condition if (newEvents.length > 0) might be clearer as a comment explaining that we only update the cursor when we've emitted new events.

Consider adding a clarifying comment:

-      // Update last created date if we have new events
       if (newEvents.length > 0) {
+        // Update cursor to the most recent event from all fetched events
         // Find the most recent created date
         const mostRecentEvent = events.reduce((latest, current) =>

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

components/ticketsauce/actions/get-orders/get-orders.mjs (2)

153-157: Add an action run summary.

Set a concise $summary so users see a helpful message in the UI.

-    return this.ticketsauce.listOrders({
+    const res = await this.ticketsauce.listOrders({
       eventId: this.eventId,
       params,
     });
+    this.$summary = `Retrieved orders for event ${this.eventId}`;
+    return res;

---

38-51: Use integer types, enforce bounds, and exclude undefined params.

The Ticketsauce app helper passes params directly to axios without sanitization or type conversion. Verify the refactor against the Ticketsauce API documentation to confirm the Max 500 per_page limit, then apply these changes:

@@
     perPage: {
-      type: "string",
+      type: "integer",
       label: "Per Page",
       description: "How many results to retrieve (per page). Max 500.",
       optional: true,
-      default: "100",
+      default: 100,
+      min: 1,
+      max: 500,
     },
     page: {
-      type: "string",
+      type: "integer",
       label: "Page",
       description: "Which page to return. For example, if per_page is 20, and page is 3, the results would show 41-60.",
       optional: true,
-      default: "1",
+      default: 1,
+      min: 1,
     },
@@
-    totalAbove: {
-      type: "string",
+    totalAbove: {
+      type: "integer",
       label: "Total Above",
       description: "Return only orders whose order total is greater than this value.",
       optional: true,
     },
     totalBelow: {
-      type: "string",
+      type: "integer",
       label: "Total Below",
       description: "Return only orders whose order total is less than this value.",
       optional: true,
     },
@@
   async run() {
-    const params = {
-      per_page: this.perPage,
-      page: this.page,
-      q: this.q,
-      return_questionnaires: this.returnQuestionnaires,
-      return_tickets: this.returnTickets,
-      return_line_item_fees: this.returnLineItemFees,
-      ordered_after: this.orderedAfter,
-      ordered_before: this.orderedBefore,
-      modified_after: this.modifiedAfter,
-      modified_before: this.modifiedBefore,
-      sort_by: this.sortBy,
-      sort_dir: this.sortDir,
-      total_above: this.totalAbove,
-      total_below: this.totalBelow,
-    };
+    const perPage = Math.min(Number(this.perPage ?? 100), 500);
+    const page = Math.max(Number(this.page ?? 1), 1);
+    const params = {
+      per_page: perPage,
+      page,
+      ...(this.q && { q: this.q }),
+      ...(this.returnQuestionnaires !== undefined && { return_questionnaires: this.returnQuestionnaires }),
+      ...(this.returnTickets !== undefined && { return_tickets: this.returnTickets }),
+      ...(this.returnLineItemFees !== undefined && { return_line_item_fees: this.returnLineItemFees }),
+      ...(this.orderedAfter && { ordered_after: this.orderedAfter }),
+      ...(this.orderedBefore && { ordered_before: this.orderedBefore }),
+      ...(this.modifiedAfter && { modified_after: this.modifiedAfter }),
+      ...(this.modifiedBefore && { modified_before: this.modifiedBefore }),
+      ...(this.sortBy && { sort_by: this.sortBy }),
+      ...(this.sortDir && { sort_dir: this.sortDir }),
+      ...(this.totalAbove !== undefined && { total_above: this.totalAbove }),
+      ...(this.totalBelow !== undefined && { total_below: this.totalBelow }),
+    };

Also applies to: lines 122-133, 135-151

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: sergio-eliot-rodriguez
PR: PipedreamHQ/pipedream#18787
File: components/ticketsauce/ticketsauce.app.mjs:7-30
Timestamp: 2025-10-17T06:58:24.566Z
Learning: The TicketSauce "List of Events" API endpoint (GET /v2/events) does not support pagination and returns all events. Users can filter the data using the available query parameters (partner_id, organization_id, etc.) rather than paginating through results.

components/microsoft_teams/sources/new-channel/new-channel.mjs (1)

8-8: Same concern as new-team-member: verify version bump necessity.

This file also shows only a version bump (0.0.12 → 0.0.13) with no functional changes, and appears unrelated to the TicketSauce-focused PR objectives.

See the review comment on components/microsoft_teams/sources/new-team-member/new-team-member.mjs for verification steps.

components/ticketsauce/actions/get-event-details/get-event-details.mjs (1)

38-48: Consider using a boolean prop type for better UX.

The past review suggested using type: "boolean" for this prop. Since the API accepts boolean values (as seen in line 58), you can simplify both the prop definition and the conversion logic:

Apply this diff:

 photos: {
-  type: "string",
+  type: "boolean",
   label: "Photos",
   description: "Whether or not to return the event's photo gallery records.",
   optional: true,
-  default: "0",
-  options: [
-    "0",
-    "1",
-  ],
+  default: false,
 },

Then simplify line 58:

 const params = {
-  photos: parseInt(this.photos) === 1,
+  photos: this.photos,
   include_performers: parseInt(this.includePerformers) === 1,
 };

This provides a better user experience (toggle instead of dropdown) and removes unnecessary conversion logic. The same refactor could apply to includePerformers if its propDefinition follows a similar pattern.

components/airweave/actions/create-collection/create-collection.mjs (1)

16-31: Add lightweight input sanitization/validation for readableId.

Fail fast and avoid an API 4xx by trimming and validating the slug shape before calling the SDK. Also trim name/description for ergonomics.

   async run({ $ }) {
-    const response = await this.airweave.createCollection({
-      name: this.name,
-      readable_id: this.readableId,
-      description: this.description,
-    });
+    const name = this.name?.trim();
+    const readable_id = this.readableId?.trim();
+    const description = this.description?.trim();
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(readable_id)) {
+      throw new Error("Readable ID must be lowercase alphanumeric words separated by single hyphens, e.g. 'customer-support-data'.");
+    }
+    const response = await this.airweave.createCollection({
+      name,
+      readable_id,
+      description,
+    });

As per component guidelines.

Also applies to: 33-38

components/airweave/package.json (1)

3-3: Package hygiene: consider adding license/repository/engines/files.

Not required, but improves publishability and tooling.

   "author": "Pipedream <[email protected]> (https://pipedream.com/)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PipedreamHQ/pipedream"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "airweave.app.mjs",
+    "actions/",
+    "sources/"
+  ],
   "publishConfig": {
     "access": "public"
   }

Also applies to: 15-18

components/airweave/actions/list-sources/list-sources.mjs (1)

18-23: Defensive count in case the SDK returns a non-array shape.

Small guard avoids response.length throwing if the SDK wraps results.

-    const count = response.length;
-    $.export("$summary", `Successfully retrieved ${count} available source connector(s)`);
+    const count = Array.isArray(response)
+      ? response.length
+      : (Array.isArray(response?.data) ? response.data.length : 0);
+    $.export("$summary", `Successfully retrieved ${count} available source connector(s)`);

components/airweave/actions/list-collections/list-collections.mjs (1)

14-33: Support “fetch all pages” to meet pagination guideline.

Add a boolean to auto-paginate; fall back to single page when false. Keeps defaults intact.

   props: {
     airweave,
+    fetchAll: {
+      type: "boolean",
+      label: "Fetch all pages",
+      description: "If enabled, retrieves all collections by following pagination.",
+      optional: true,
+      default: false,
+    },
     skip: {
@@
   async run({ $ }) {
-    const response = await this.airweave.listCollections({
-      skip: this.skip,
-      limit: this.limit,
-    });
+    const doFetchAll = !!this.fetchAll;
+    let response = [];
+    if (doFetchAll) {
+      let skip = this.skip ?? 0;
+      const limit = this.limit ?? 50;
+      // Defensive loop with cap
+      for (let i = 0; i < 200; i++) {
+        const page = await this.airweave.listCollections({ skip, limit });
+        const items = Array.isArray(page) ? page : (page?.results || []);
+        response.push(...items);
+        if (items.length < limit) break;
+        skip += items.length;
+      }
+    } else {
+      const page = await this.airweave.listCollections({ skip: this.skip, limit: this.limit });
+      response = Array.isArray(page) ? page : (page?.results || []);
+    }
 
-    const count = response.length;
+    const count = response.length;
     $.export("$summary", `Successfully retrieved ${count} collection(s)`);
 
     return response;
   },

Confirm listCollections returns an array vs an object with results/next cursor. If the SDK exposes total/next, we can switch to that for precision.

Also applies to: 34-44

components/airweave/actions/search-collection/search-collection.mjs (1)

75-79: Adjust summary for completion vs results.

When responseType is “completion”, results may be empty; tailor the summary accordingly.

-    const resultCount = response.results?.length || 0;
-    $.export("$summary", `Successfully searched collection "${this.collectionId}" and found ${resultCount} result(s)`);
+    const mode = this.responseType || "results";
+    if (mode === "completion") {
+      const hasAnswer = !!(response?.completion || response?.answer);
+      $.export("$summary", `Generated completion for collection "${this.collectionId}"${hasAnswer ? "" : " (no answer)"}`);
+    } else {
+      const resultCount = response.results?.length || 0;
+      $.export("$summary", `Searched collection "${this.collectionId}" and found ${resultCount} result(s)`);
+    }
 
     return response;

Please confirm the SDK uses response_type and offset param names (vs format/skip) and completion field name (completion vs answer).

Also applies to: 34-39

components/airweave/airweave.app.mjs (3)

33-53: Same pagination hint for sourceConnectionId options.

Mirror the hasMore/next token approach here, too, to avoid UI calling without a stop condition.

         return {
           options: connections.map((conn) => ({
             label: conn.name || conn.id,
             value: conn.id,
           })),
-          context: {
-            skip: params.skip + connections.length,
-          },
+          context: {
+            skip: params.skip + connections.length,
+            hasMore: connections.length === params.limit,
+          },
         };

---

93-100: Cache the SDK client to reduce per-call instantiation overhead.

Lightweight but cleaner and cheaper at runtime.

-    _client() {
-      return new AirweaveSDKClient({
-        apiKey: this._apiKey(),
-        baseUrl: this._baseUrl(),
-        frameworkName: "pipedream",
-        frameworkVersion: "0.1.0",
-      });
-    },
+    _client() {
+      if (!this._clientInstance) {
+        this._clientInstance = new AirweaveSDKClient({
+          apiKey: this._apiKey(),
+          baseUrl: this._baseUrl(),
+          frameworkName: "pipedream",
+          frameworkVersion: "0.1.0",
+        });
+      }
+      return this._clientInstance;
+    },

---

86-100: Optional: expose a test() method for connection validation.

Useful for “Test” button and clearer auth failures.

   methods: {
+    async test() {
+      // Lightweight call to validate credentials and base URL
+      await this.listSources();
+      return { ok: true };
+    },

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro